from .core_handler import CoreHandler, UnlockState
from .multi_task_handler import MultiTaskHandler, UnlockTask
import logging
import sys
import argparse
from .config import Config
from .proxy_manager import ProxyManager
import time
from .package.variables import variables
import requests
import json
from typing import List, Dict

# 设置日志级别
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

def send_result_to_backend(record_id: int, imei: str, success: bool, message: str) -> bool:
    """
    将解锁结果发送到后台
    :param record_id: 解锁记录ID
    :param imei: IMEI号
    :param success: 是否成功
    :param message: 结果消息
    :return: 是否发送成功
    """
    try:
        # 构建请求数据
        data = {
            "id": record_id,
            "imei": imei,
            "success": success,
            "message": message
        }
        
        # 发送POST请求
        logger.info(f"正在发送解锁结果到后台: data={data}")
        response = requests.post(
            "http://localhost:8001/unlock/result",
            json=data,
            headers={"Content-Type": "application/json"}
        )
        
        # 检查响应
        if response.status_code == 200:
            result = response.json()
            if result.get("code") == 200:
                logger.info("结果回调成功")
                return True
            else:
                # 如果返回消息是"操作成功"，也认为是成功的
                if result.get("msg") == "操作成功":
                    logger.info("结果回调成功")
                    return True
                logger.error(f"结果回调失败: {result.get('msg')}")
                return False
        else:
            logger.error(f"结果回调请求失败: {response.status_code}")
            return False
            
    except Exception as e:
        logger.error(f"发送结果到后台时出错: {str(e)}")
        return False

def unlock_device(record_id: int, imei: str, email: str, first_name: str, last_name: str, phone: str, is_test: bool = False) -> bool:
    """
    解锁设备的主要逻辑
    :param record_id: 解锁记录ID
    :param imei: 设备IMEI号
    :param email: 邮箱
    :param first_name: 名字
    :param last_name: 姓氏
    :param phone: 电话号码
    :param is_test: 是否为测试模式，如果为True则不发送结果到后台
    :return: 是否成功
    """
    try:
        # 初始化代理管理器
        proxy_manager = ProxyManager()
        initial_ip = proxy_manager.refresh_ip()
        if not initial_ip:
            error_msg = "初始化代理失败，请检查代理配置"
            logger.error(error_msg)
            if not is_test:
                send_result_to_backend(record_id, imei, False, error_msg)
            return False
            
        logger.info(f"初始化代理成功，当前IP: {initial_ip}")
        
        # 设置全局代理配置
        variables['proxy_manager'] = proxy_manager
        
        # 初始化配置
        Config.init()
        
        # 创建任务对象
        task = UnlockTask(
            record_id=record_id,
            imei=imei,
            email=email,
            first_name=first_name,
            last_name=last_name,
            phone=phone,
            is_test=is_test
        )
        
        # 使用多任务处理器处理单个任务
        results = process_tasks([task])
        success = results.get(record_id, False)
        
        return success
        
    except Exception as e:
        error_msg = f"程序执行出错: {str(e)}"
        logger.error(error_msg)
        if not is_test:
            send_result_to_backend(record_id, imei, False, error_msg)
        return False

def test_unlock():
    """
    测试解锁功能
    用于本地调试，使用测试数据
    """
    test_data = {
        'id': 1,
        'imei': '353220108099794',
        'email': 'zuwz469@amail.vip',
        'first_name': 'John',
        'last_name': 'lowell',
        'phone': '9514555990'
    }
    
    success = unlock_device(
        record_id=test_data['id'],
        imei=test_data['imei'],
        email=test_data['email'],
        first_name=test_data['first_name'],
        last_name=test_data['last_name'],
        phone=test_data['phone'],
        is_test=True  # 设置为测试模式
    )
    
    logger.info(f"测试结果: {'成功' if success else '失败'}")
    return success

def process_tasks(tasks: List[UnlockTask], max_workers: int = 3) -> Dict[int, bool]:
    """
    处理多个解锁任务
    :param tasks: 解锁任务列表
    :param max_workers: 最大并行任务数
    :return: 任务结果字典，key为记录ID，value为是否成功
    """
    try:
        # 确保max_workers不超过任务数量
        actual_workers = min(max_workers, len(tasks))
        logger.info(f"使用 {actual_workers} 个工作线程处理 {len(tasks)} 个任务")
        
        # 初始化多任务处理器
        handler = MultiTaskHandler(max_workers=actual_workers)
        
        # 添加所有任务
        for task in tasks:
            handler.add_task(task)
            
        # 运行所有任务
        results = handler.run_all_tasks()
        
        return results
        
    except Exception as e:
        logger.error(f"处理任务失败: {str(e)}")
        return {}

def check_unlock_status(record_id: int, request_number: str, imei: str = None, retry_count: int = 0) -> bool:
    """
    查询设备解锁状态
    :param record_id: 解锁记录ID
    :param request_number: AT&T解锁请求编号
    :param imei: 设备IMEI号码(可选，但提供可增加查询成功率)
    :param retry_count: 当前重试次数
    :return: 是否成功获取最终结果
    """
    try:
        # 最大重试次数，每次运行只尝试一次查询，但会记录重试次数
        max_retries = 24  # 最多重试24次，相当于24小时
        
        logger.info(f"开始查询解锁状态，记录ID: {record_id}, 请求编号: {request_number}, IMEI: {imei or '未提供'}, 重试次数: {retry_count}")
        
        # 检查是否超过最大重试次数
        if retry_count >= max_retries:
            logger.error(f"超过最大重试次数({max_retries})，停止查询")
            # 打印状态码（超时）
            print(f"STATUS:8 解锁状态查询超时，请手动查询")
            # 发送超时消息到后台
            send_result_to_backend(
                record_id=record_id,
                imei=imei or "",
                success=False,
                message="解锁状态查询超时，请手动查询"
            )
            return False
        
        # 初始化代理管理器
        proxy_manager = ProxyManager()
        initial_ip = proxy_manager.refresh_ip()
        if not initial_ip:
            error_msg = "初始化代理失败，请检查代理配置"
            logger.error(error_msg)
            print(f"STATUS:4 {error_msg}")
            return False
            
        logger.info(f"初始化代理成功，当前IP: {initial_ip}")
        
        # 设置全局代理配置
        variables['proxy_manager'] = proxy_manager
        
        # 初始化配置
        Config.init()
        
        # 创建CoreHandler
        handler = CoreHandler()
        
        # 初始化浏览器
        if not handler.setup():
            logger.error("浏览器初始化失败")
            print(f"STATUS:4 浏览器初始化失败")
            return False
        
        try:
            # 导航到状态查询页面
            if not handler.navigate_status_page():
                logger.error("导航到状态查询页面失败")
                print(f"STATUS:4 导航到状态查询页面失败")
                return False
            
            # 填写查询表单
            if not handler.fill_status_form(request_number, imei):
                logger.error("填写查询表单失败")
                print(f"STATUS:4 填写查询表单失败")
                return False
            
            # 查询并解析结果
            # 注意: parse_result_page方法已经会打印标准格式的状态
            success = handler.query_unlock_status(request_number, imei)
            
            return success
        
        finally:
            # 清理资源
            handler.close()
        
    except Exception as e:
        logger.error(f"查询解锁状态时出错: {str(e)}")
        print(f"STATUS:4 查询解锁状态时出错: {str(e)}")
        return False

def main():
    """
    主函数，处理命令行参数
    """
    parser = argparse.ArgumentParser(description='ATT设备解锁工具')
    subparsers = parser.add_subparsers(dest='command', help='可用命令')
    
    # unlock命令
    unlock_parser = subparsers.add_parser('unlock', help='解锁设备')
    unlock_parser.add_argument('--id', required=True, type=int, help='解锁记录ID')
    unlock_parser.add_argument('--imei', required=True, help='设备IMEI号')
    unlock_parser.add_argument('--email', required=True, help='邮箱地址')
    unlock_parser.add_argument('--first-name', required=True, help='名字')
    unlock_parser.add_argument('--last-name', required=True, help='姓氏')
    unlock_parser.add_argument('--phone', required=True, help='电话号码')
    
    # batch命令
    batch_parser = subparsers.add_parser('batch', help='批量解锁设备')
    batch_parser.add_argument('--file', help='包含任务信息的JSON文件路径')
    batch_parser.add_argument('--workers', type=int, default=3, help='最大并行任务数')
    batch_parser.add_argument('--tasks', help='任务数据，格式为: id,imei,email,first_name,last_name,phone;id2,imei2,email2,...')
    
    # test命令
    test_parser = subparsers.add_parser('test', help='测试解锁功能')
    
    # status命令 - 新增
    status_parser = subparsers.add_parser('status', help='查询解锁状态')
    status_parser.add_argument('--id', required=True, type=int, help='解锁记录ID')
    status_parser.add_argument('--request-number', required=True, help='AT&T解锁请求编号')
    status_parser.add_argument('--imei', help='设备IMEI号码(可选)')
    status_parser.add_argument('--retry', type=int, default=0, help='当前重试次数')
    
    args = parser.parse_args()
    
    if args.command == 'unlock':
        # 单个任务处理
        task = UnlockTask(
            record_id=args.id,
            imei=args.imei,
            email=args.email,
            first_name=args.first_name,
            last_name=args.last_name,
            phone=args.phone
        )
        results = process_tasks([task])
        success = results.get(args.id, False)
        
    elif args.command == 'batch':
        # 批量任务处理
        try:
            if args.file:
                # 从JSON文件读取
                with open(args.file, 'r', encoding='utf-8') as f:
                    task_data = json.load(f)
                tasks = [UnlockTask(**data) for data in task_data]
            elif args.tasks:
                # 从命令行参数解析
                tasks = []
                task_strings = args.tasks.split(';')
                for task_str in task_strings:
                    if not task_str.strip():
                        continue
                    id_str, imei, email, first_name, last_name, phone = task_str.split(',')
                    task = UnlockTask(
                        record_id=int(id_str),
                        imei=imei,
                        email=email,
                        first_name=first_name,
                        last_name=last_name,
                        phone=phone
                    )
                    tasks.append(task)
            else:
                logger.error("必须提供--file或--tasks参数之一")
                return False
                
            # 使用命令行参数中的workers值
            results = process_tasks(tasks, max_workers=args.workers)
            success = all(results.values())
            
        except Exception as e:
            logger.error(f"批量处理失败: {str(e)}")
            success = False
            
    elif args.command == 'test':
        success = test_unlock()
        
    elif args.command == 'status':
        # 查询解锁状态
        success = check_unlock_status(
            record_id=args.id,
            request_number=args.request_number,
            imei=args.imei,
            retry_count=args.retry
        )
        
        # 如果没有获取到最终结果，表示需要继续查询
        if not success:
            logger.info("未获取到最终结果，将在下次查询")
            
    else:
        parser.print_help()
        return False
        
    return success

if __name__ == "__main__":
    success = main()
    sys.exit(0 if success else 1) 